﻿using ERPEF;
using ERPEF.Model;
using ERPIService;
using Microsoft.EntityFrameworkCore;
using S4Project;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ERPService
{
    public class bs_dict_dataService : bs_dict_dataIService
    {
        private readonly MyDbContext MyDbContext;
        public bs_dict_dataService(MyDbContext myDb)
        {
            this.MyDbContext = myDb;
        }
        //客户属性添加
        public async Task<int> clientAdd(bs_dict_data DictData)
        {

            if (DictData == null)
            {
                throw new ArgumentNullException(nameof(DictData));
            }

            // 根据type字段获取当前最大的sort值
            int maxSort = await MyDbContext.bs_dict_data
                .Where(d => d.dd_type == DictData.dd_type)
                .Select(d => (int?)d.dd_sort)
                .MaxAsync() ?? 0; // 使用空合并运算符处理没有记录的情况

            // 将新数据的sort值设置为当前最大的sort值加一
            DictData.dd_sort = maxSort + 1;

            await MyDbContext.bs_dict_data.AddAsync(DictData);
            return await MyDbContext.SaveChangesAsync();
           
        }
        //客户属性修改
        public async Task<int> clientUpdate(bs_dict_data DictData)
        {
            MyDbContext.bs_dict_data.Update(DictData);
            return await MyDbContext.SaveChangesAsync();
        }
        //客户逻辑删除
        public async Task<int> clientDelete(int dd_code)
        {
            var del = MyDbContext.bs_dict_data.Find(dd_code);
            if (del != null)
            {
                del.IsDeleted = true;
                await MyDbContext.SaveChangesAsync();
                return 1;
            }
            return 0;
        }

        //物品属性添加
        public async Task<int> goodsAdd(bs_dict_data DictData)
        {
            if (DictData == null)
            {
                throw new ArgumentNullException(nameof(DictData));
            }

            // 根据type字段获取当前最大的sort值
            int maxSort = await MyDbContext.bs_dict_data
                .Where(d => d.dd_type == DictData.dd_type)
                .Select(d => (int?)d.dd_sort)
                .MaxAsync() ?? 0; // 使用空合并运算符处理没有记录的情况

            // 将新数据的sort值设置为当前最大的sort值加一
            DictData.dd_sort = maxSort + 1;

            await MyDbContext.bs_dict_data.AddAsync(DictData);
            return await MyDbContext.SaveChangesAsync();
        }
        //物品属性修改
        public async Task<int> goodsUpdate(bs_dict_data DictData)
        {
            MyDbContext.bs_dict_data.Update(DictData);
            return await MyDbContext.SaveChangesAsync();
        }


        //客户属性查询
        public async Task<List<bs_dict_data>> Queryclient()
        {
            // return await MyDbContext.bs_Warehouse.ToListAsync();
            return await MyDbContext.bs_dict_data
         .Where(w => w.IsDeleted == false && w.dd_type == "type_client")
         .ToListAsync();
        }
        //物品属性查询
        public async Task<List<bs_dict_data>> Querygoods()
        {
            return await MyDbContext.bs_dict_data
         .Where(w => w.IsDeleted == false && w.dd_type == "type_goods")
         .ToListAsync();
        }
        //物品逻辑删除
        public async Task<int> goodsDelete(int dd_code)
        {
            var del = MyDbContext.bs_dict_data.Find(dd_code);
            if (del != null)
            {
                del.IsDeleted = true;
                await MyDbContext.SaveChangesAsync();
                return 1;
            }
            return 0;
        }
        //计量单位查询
        public async Task<List<bs_dict_data>> Queryunit()
        {
            return await MyDbContext.bs_dict_data
        .Where(w => w.IsDeleted == false && w.dd_type == "type_unit")
        .ToListAsync();
        }
        //计量单位添加
        public async Task<int> unitAdd(bs_dict_data DictData)
        {
            if (DictData == null)
            {
                throw new ArgumentNullException(nameof(DictData));
            }

            // 根据type字段获取当前最大的sort值
            int maxSort = await MyDbContext.bs_dict_data
                .Where(d => d.dd_type == DictData.dd_type)
                .Select(d => (int?)d.dd_sort)
                .MaxAsync() ?? 0; // 使用空合并运算符处理没有记录的情况

            // 将新数据的sort值设置为当前最大的sort值加一
            DictData.dd_sort = maxSort + 1;

            await MyDbContext.bs_dict_data.AddAsync(DictData);
            return await MyDbContext.SaveChangesAsync();
        }
        //计量单位修改
        public async Task<int> unitUpdate(bs_dict_data DictData)
        {
            MyDbContext.bs_dict_data.Update(DictData);
            return await MyDbContext.SaveChangesAsync();
        }
        //计量单位删除
        public async Task<int> unitDelete(int dd_code)
        {
            var del = MyDbContext.bs_dict_data.Find(dd_code);
            if (del != null)
            {
                del.IsDeleted = true;
                await MyDbContext.SaveChangesAsync();
                return 1;
            }
            return 0;
        }
    }
}
